﻿#pragma once
#ifndef XL_XEXPAND_DWEBX_WODLLEXPORT_H
//@隐藏{
#define XL_XEXPAND_DWEBX_WODLLEXPORT_H
struct WoRefModelInfo;

#ifdef WEBOAT_EXPORTS
#include "pch.h"
#include "module_WebOat.h"

#else

//class WoHttpRouterPtr;
struct WoHttpControllerModel;

#endif
struct WoRefModelInfo;

WEBOAT_MODIFICATION void WEBOAT_API WoHTTPSetErrorHander(WoHttpRouterPtr& r, void* func);
//@隐藏}


//@分组{  枚举值

//@别名 WEB_绑定IP
enum WoNetworkAddress {
	//@别名 WEB_绑定IP_IP4
	IP4 = 0,
	//@别名 WEB_绑定IP_IP6
	IP6 = 1,
	//@别名 WEB_绑定IP_未指定
	UNSPEC = 2,
};

//@别名 WEB_请求类型
enum WoHTTPMethod {
	//@备注 向服务器获取资源，比如常见的查询请求
	//@别名 WEB_请求类型_GET
	_GET,
	//@备注 向服务器提交数据而发送的请求 
	//@别名 WEB_请求类型_POST
	_POST,
	//@备注 和get类似，返回的响应中没有具体的内容，用于获取报头
	//@别名 WEB_请求类型_HEAD
	_HEAD,
	//@备注 一般是用于更新请求，比如更新个人信息、商品信息全量更新 
	//@别名 WEB_请求类型_PUT
	_PUT,
	//@备注 PUT 方法的补充,更新指定资源的部分数据 
	//@别名 WEB_请求类型_PATCH
	_PATCH,
	//@备注 用于删除指定的资源 
	//@别名 WEB_请求类型_DELETE
	_DELETE,
	//@备注 获取服务器支持的HTTP请求方法,服务器性能、跨域检查等 
	//@别名 WEB_请求类型_OPTIONS
	_OPTIONS,
	//@备注 方法的作用就是把服务器作为跳板，让服务器代替用户去访问其它网页，之后把数据原原本本的返
	// .回给用户，网页开发基本不用这个方法，如果是http代理就会使用这个，让服务器代理用户去访问其他网页，类似中介
	//@别名 WEB_请求类型_CONNECT
	_CONNECT,
	//@备注 回显服务器收到的请求，主要用于测试或诊断
	//@别名 WEB_请求类型_TRACE
	_TRACE,
};


//@分组}
//@分组{  导出函数

//@别名 Web_初始化环境()
WEBOAT_MODIFICATION void WEBOAT_API WoInit();
//@别名 Web_清理环境()
WEBOAT_MODIFICATION void WEBOAT_API WoDestroy();
//@备注 为 HTTP 请求创建路由器
//@别名 Web_创建路由()
WEBOAT_MODIFICATION WoHttpRouterPtr WEBOAT_API WoCreateRouter();
//@备注 创建 HTTP 连接处理程序
//@别名 Web_创建连接程序()
WEBOAT_MODIFICATION WoHttpConnectHanderPtr WEBOAT_API WoCreateHttpConnectionHander(WoHttpRouterPtr router);
//@备注 创建 TCP 连接提供者
//@别名 Web_创建连接提供者()
WEBOAT_MODIFICATION WoHttpServerConnectionProviderPtr WEBOAT_API WoCreateConnectionProvider(const char* host, int port, int IpAddress);
//@备注 创建服务器，它接受提供的 TCP 连接并将其传递给 HTTP 连接处理程序
//@别名 Web_服务器_创建()
WEBOAT_MODIFICATION WoServerPtr WEBOAT_API WoCreateServer(WoHttpServerConnectionProviderPtr cpPtr, WoHttpConnectHanderPtr connectPtr);
//@别名 Web_服务器_运行(服务器指针)
WEBOAT_MODIFICATION void WEBOAT_API WoServerRun(WoServerPtr& serverPtr);
//@别名 Web_服务器_停止()
WEBOAT_MODIFICATION void WEBOAT_API WoServerStop(WoServerPtr& serverPtr);
//@参数 回调函数 参见: Web_回调原型_HTTP错误回调
//@别名 Web_服务器_置全局错误回调(回调函数)
WEBOAT_MODIFICATION void WEBOAT_API WoHTTPSetGlobalHandlerError(WoHTTPHanderErrorFunc func);
//@别名 Web_服务器_是否正在运行(服务器指针)
WEBOAT_MODIFICATION bool WEBOAT_API WoServerIsRuning(WoServerPtr& serverPtr);
//@备注 可以中断路由,将代码流转向错误处理
// .注意: 此函数尽量只在路由函数作用域内使用
// .因为路由会捕获此函数抛出的错误,如果函数外层没有错误捕获器程序则会崩溃!!!
//@别名 Wo抛出错误(响应代码,错误信息)
WEBOAT_MODIFICATION void WEBOAT_API WoHTTPThrowException(int code, const char* msg);

//@备注 注册全局路由
//@参数 路由指针 注册的路由指针
//@参数 请求类型 参考枚举类型 WEB_请求类型_ / WoHTTPMethod_
//@参数 路径 请求的资源路径,例如: /hello
//@参数 处理类指针 使用回调创建的回调指针
//@参数 保留参数 空即可
//@别名 Web_路由_注册路由(路由指针,请求类型,路径,处理类指针,保留参数)
WEBOAT_MODIFICATION void WEBOAT_API WoRegisterRouter(WoHttpRouterPtr router, int Methods, const char* path, WoRequestHandlerPtr hander, void* parame1=nullptr);
//@备注 注册全局路由
//@参数 路由指针 注册的路由指针
//@参数 访问路径 请求的资源路径,例如: /hello
//@参数 映射路径 映射到本地的路径
//@参数 保留参数 空即可
//@别名 Web_路由_注册静态路由(路由指针,访问路径,映射路径,保留参数)
WEBOAT_MODIFICATION void WEBOAT_API WoRegisterStaticRouter(WoHttpRouterPtr router, const char* path, const char* localPath, void* parame1=nullptr);
//@别名 Web_路由_注册回调(回调函数)
WEBOAT_MODIFICATION WoRequestHandlerPtr WEBOAT_API WoCreateRequestHandler(WoHttpControllerModel& CallFunc);
//@别名 Web_路由_注册回调Ex(回调函数组)
WEBOAT_MODIFICATION WoRequestHandlerPtr WEBOAT_API WoCreateRequestHandlerEx(CXVector<WoHttpControllerModel>& funcs);
//@别名 Web_路由_下一个路由(请求指针)
WEBOAT_MODIFICATION void WEBOAT_API WoRequestHanderNext(const WoHTTPIncomingRequestPtr& req);
//@别名 Web_路由_中断路由(请求指针)
WEBOAT_MODIFICATION void WEBOAT_API WoRequestHanderAbort(const WoHTTPIncomingRequestPtr& req);

//@参数 名称 如:/user/{userId} ,则使用 "userId"
//@别名 Web_请求_取路径变量(请求指针,名称)
WEBOAT_MODIFICATION CXTextA WEBOAT_API WoRequestGetPathVariable(const WoHTTPIncomingRequestPtr& req, const char* name);
//@备注 取出所有路径变量
//@参数 返回数据 例如 /delete/{name}/{id} -> /delete/huiyi/1 ,取回 map{"name":"huiyi","id":"1"}
//@别名 Web_请求_取所有路径变量(请求指针,返回数据)
WEBOAT_MODIFICATION void WEBOAT_API WoRequestGetPathVariables(const WoHTTPIncomingRequestPtr& req, CXMap<CXTextA, CXTextA>& rmap);
//@别名 Web_请求_取查询参数(请求指针,参数名)
WEBOAT_MODIFICATION CXTextA WEBOAT_API WoRequestGetQueryParameter(const WoHTTPIncomingRequestPtr& req, const char* key);
//@备注 例如 /path?id=1 返回 "?id=1"
//@别名 Web_请求_取路径尾(请求指针)
WEBOAT_MODIFICATION CXTextA WEBOAT_API WoRequestGetPathTail(const WoHTTPIncomingRequestPtr& req);
//@别名 Web_请求_取请求头(请求指针,键名);
WEBOAT_MODIFICATION CXTextA WEBOAT_API WoRequestGetHeader(const WoHTTPIncomingRequestPtr& req, const char* key);
//@别名 Web_请求_取所有请求头(请求指针,返回数据);
WEBOAT_MODIFICATION void WEBOAT_API WoRequestGetHeaders(const WoHTTPIncomingRequestPtr& req, CXMap<CXTextA, CXTextA>& rmap);
//@别名 Web_请求_取Body文本(请求指针,返回文本)
WEBOAT_MODIFICATION void WEBOAT_API WoRequestGetBodyToString(const WoHTTPIncomingRequestPtr& req, CXTextA& str);
//@别名 Web_请求_取Body数据(请求指针,返回文字节集)
WEBOAT_MODIFICATION void WEBOAT_API WoRequestGetBodyToByte(const WoHTTPIncomingRequestPtr& req, CXBytes& data);
//@备注 仅支持 application/x-www-form-urlencoded
//@别名 Web_请求_取PostFrom值(上下文,键)
WEBOAT_MODIFICATION CXTextA WEBOAT_API WoRequestGetPostForm(WoHTTPContext* ctx, const char* key);
//@备注 快速获取请求头中的JWT文本
// .例如: 当 参数[请求头]="Authorization"
// .当 参数[前缀]="Bearer"时
// 对应: Authorization: Bearer JWTSTR
//@别名 Web_请求_取JWT文本(请求指针,请求头,前缀)
WEBOAT_MODIFICATION CXTextA WEBOAT_API WoRequestGetJWTAuthStr(const WoHTTPIncomingRequestPtr& req, const char* hander = "Authorization", const char* prefix = "Bearer");

//@备注 自动从 application/x-www-form-urlencoded 或者 application/json 数据流中获取数据并填充反射信息.
// .注意:数据类名与类型请勿对应错误,会发生不可预知的问题.
//@别名 Web_请求_取Post数据_自动反射(上下文,模型类型名称,填充地址)
WEBOAT_MODIFICATION bool WEBOAT_API WoRequestGetPostToBind(WoHTTPContext* ctx, const char* typeName, void* ptr);
//@隐藏{
//WEBOAT_MODIFICATION bool WEBOAT_API WoRequestGetPostToBind(WoHTTPContext* ctx, WoRefIterator& iter, void* ptr);
//@隐藏}

//@别名 Web_请求_取请求Path(请求指针)
WEBOAT_MODIFICATION CXTextA WEBOAT_API WoRequestGetPath(const WoHTTPIncomingRequestPtr& req);


//@别名 Web_回复_创建简易(响应代码,回复数据)
WEBOAT_MODIFICATION WoHTTPOutgoingResponsePtr WEBOAT_API WoCreateResponseFast(int code, const char* data);
//@别名 Web_回复_添加头(响应指针,键,值)
WEBOAT_MODIFICATION void WoResponsePutHeader(WoHTTPOutgoingResponsePtr& resp, const char* Key, const char* value);
//@别名 Web_回复_获取头(响应指针,键)
WEBOAT_MODIFICATION CXTextA WoResponseGetHeader(WoHTTPOutgoingResponsePtr& resp, const char* Key);
//@别名 Web_回复_获取所有头(响应指针,返回数据)
WEBOAT_MODIFICATION void WoResponseGetHeaders(WoHTTPOutgoingResponsePtr& resp, CXMap<CXTextA, CXTextA>& rmap);
//@别名 Web_回复_Body添加数据(响应指针,数据缓冲区,缓冲区尺寸)
WEBOAT_MODIFICATION void WoResponseBodyAddBuffer(WoHTTPOutgoingResponsePtr& resp, const char* data, UINT size);
//@别名 Web_回复_Body添加文本(响应指针,文本数据)
WEBOAT_MODIFICATION void WoResponseBodyAddTextA(WoHTTPOutgoingResponsePtr& resp, const char* data);
//@别名 Web_回复_Body设置数据(响应指针,数据缓冲区,缓冲区尺寸)
WEBOAT_MODIFICATION void WoResponseBodySetBuffer(WoHTTPOutgoingResponsePtr& resp, const char* data, UINT size);
//@别名 Web_回复_Body设置文本(响应指针,文本数据)
WEBOAT_MODIFICATION void WoResponseBodySetTextA(WoHTTPOutgoingResponsePtr& resp, const char* data);
//@别名 Web_回复_Body取大小(响应指针)
WEBOAT_MODIFICATION size_t WoResponseBodySize(WoHTTPOutgoingResponsePtr& resp);
//@别名 Web_回复_Body取数据(响应指针,接收变量)
WEBOAT_MODIFICATION void WEBOAT_API WoResponseGetData(WoHTTPOutgoingResponsePtr& resp, CXBytes& ret);
//@备注 获取当前传出的状态码
//@别名 Web_回复_取状态码(响应指针)
WEBOAT_MODIFICATION int WEBOAT_API WoResponseGetStatus(WoHTTPOutgoingResponsePtr& resp);
//@备注 将渲染数据快速返回到前端
//@别名 Web_回复_回复JSON_渲染数据(响应指针,渲染数据集)
WEBOAT_MODIFICATION void WEBOAT_API WoResponseSendJsonByTemplate(WoHTTPOutgoingResponsePtr& resp, WoTemplateJson& json);
//@备注 将渲染数据快速返回到前端
//@别名 Web_回复_回复结构体(响应指针,模型名称,模型指针)
WEBOAT_MODIFICATION void WEBOAT_API WoResponseSendJsonByModel(WoHTTPOutgoingResponsePtr& resp, const char* modelName, void* modePtr);

//@别名 Web_状态码_创建(响应码,描述)
WEBOAT_MODIFICATION WoHTTPStatus WEBOAT_API WoCreateStatus(int code, const char* description);
//@别名 Web_状态码_200()
WEBOAT_MODIFICATION WoHTTPStatus WEBOAT_API WoCreateStatusTo200();

//WEBOAT_MODIFICATION void WEBOAT_API WoRequestGetClientIP(const WoHTTPIncomingRequestPtr& req);

//WEBOAT_MODIFICATION void WEBOAT_API WoRequestParsePostForm(const WoHTTPIncomingRequestPtr& req);
//WEBOAT_MODIFICATION void test(const WoHTTPIncomingRequestPtr& req);


//@分组}
//@分组{  模板类导出函数

//@备注 创建模板渲染器
//@别名 Wo渲染模板_创建()
WEBOAT_MODIFICATION WoTemplateEnvironment WEBOAT_API WoTemplateCreate();
//@别名 Wo渲染模板_快速渲染(输入数据,数据集)
WEBOAT_MODIFICATION CXTextA WEBOAT_API WoTemplateQuickRender(const char* input, WoTemplateJson& render);
//@备注 创建用于模板渲染器的数据集
//@别名 Wo渲染模板_创建数据集()
WEBOAT_MODIFICATION WoTemplateJson WEBOAT_API WoTemplateJsonCreate();
//@备注 使用渲染器渲染模板文本
//@别名 Wo渲染模板_渲染器_文本(渲染器,模板文本,渲染数据,返回数据)
WEBOAT_MODIFICATION void WEBOAT_API WoTemplateEnvRender(WoTemplateEnvironment& env, const char* tempStr, WoTemplateJson& data, CXTextA& rest);
//@备注 使用渲染器渲染模板文件
//@别名 Wo渲染模板_渲染器_文件(渲染器,模板文件,渲染数据,返回数据)
WEBOAT_MODIFICATION void WEBOAT_API WoTemplateEnvRenderFile(WoTemplateEnvironment& env, const char* tempPath, WoTemplateJson& data, CXTextA& rest);
//@备注 使用渲染器渲染模板文件,数据使用json文件
//@别名 Wo渲染模板_渲染器_文件_Json数据(渲染器,模板文本,数据路径,返回数据)
WEBOAT_MODIFICATION void WEBOAT_API WoTemplateEnvRenderFileJson(WoTemplateEnvironment& env, const char* tempPath, const char* jsonPath, CXTextA& rest);
//@备注 设置具有模板文件的全局路径和文件保存位置
//@别名 Wo渲染模板_渲染器_置全局路径(渲染器,全局路径)
WEBOAT_MODIFICATION void WEBOAT_API WoTemplateEnvSetGlobalPath(WoTemplateEnvironment& env, const char* path);
//@备注 置模板输入位置,渲染器会进入此目录寻找模板文件
//@别名 Wo渲染模板_渲染器_置输入路径(渲染器,输入路径)
WEBOAT_MODIFICATION void WEBOAT_API WoTemplateEnvSetInputPath(WoTemplateEnvironment& env, const char* path);
//@备注 置模板输入位置,渲染器渲染完成后的模板会保存在此
//@别名 Wo渲染模板_渲染器_置输出路径(渲染器,输入路径)
WEBOAT_MODIFICATION void WEBOAT_API WoTemplateEnvSetOutputPath(WoTemplateEnvironment& env, const char* path);

//@分组}
//@隐藏{
#ifdef _WIN32
WEBOAT_MODIFICATION void _WoCodingGBK2UTF8_Win1(const char* gbkStr, CXTextA& retStr);
WEBOAT_MODIFICATION void _WoCodingUTF82GBK_Win1(const char* utf8Str, CXTextA& retStr);
WEBOAT_MODIFICATION CXTextA _WoCodingGBK2UTF8_Win(const char* gbkStr);
WEBOAT_MODIFICATION CXTextA _WoCodingUTF82GBK_Win(const char* utf8Str);
#define WoCodingGBK2UTF8 _WoCodingGBK2UTF8_Win
#define WoCodingUTF82GBK _WoCodingUTF82GBK_Win
#define WoCodingGBK2UTF8Ex _WoCodingGBK2UTF8_Win1
#define WoCodingUTF82GBKEx _WoCodingUTF82GBK_Win1
#endif
//@隐藏}
//@分组{ 编码类函数

//@别名 Wo编码_URL解码A(文本)
WEBOAT_MODIFICATION CXTextA WEBOAT_API WoCodingUrlDecodeA(const char* str);
//@别名 Wo编码_URL编码A(文本)
WEBOAT_MODIFICATION CXTextA WEBOAT_API WoCodingUrlEncodeA(const char* str);

/*@声明

//@别名 Wo编码_GBK到UTF8(GBK文本)
typedef CXTextA (_WoCodingGBK2UTF8_Win)(const char* gbkStr);
//@别名 Wo编码_UTF8到GBK(UTF8文本)
typedef CXTextA (_WoCodingUTF82GBK_Win)(const char* utf8Str);
//@别名 Wo编码_GBK到UTF8Ex(GBK文本,返回数据)
typedef void (_WoCodingGBK2UTF8_Win1)(const char* gbkStr, CXTextA& retStr);
//@别名 Wo编码_UTF8到GBKEx(UTF8文本,返回数据)
typedef void (_WoCodingUTF82GBK_Win1)(const char* utf8Str, CXTextA& retStr);

*/

//@分组}
//@分组{	反射类函数

//@别名 Wo反射模型句柄
typedef WoRefModelInfo* WoRefModelHandle;

//@备注 反射函数
//@参数 待填充地址 将被填充的变量的原始地址,需要自行解引用,指针非安全,请谨慎使用.
//@参数 用于填充的原始数据 待填充的数据,始终为cahr*,自动转换
//@别名 Wo反射模型_基础数据_反射回调(待填充地址,用于填充的原始数据)
typedef bool(*WoRefBaseModelFunc)(void* ModelPtr, const char* RefData);
//@备注 反射函数
//@参数 待填充地址 将被填充的变量的原始地址,需要自行解引用,指针非安全,请谨慎使用.
//@参数 用于填充的原始数据 待填充的数据,始终为cahr*,自动转换
//@别名 Wo反射模型_基础数据_序列化回调(待填充地址,被填充的文本)
typedef void(*WoRefBaseModelSezFunc)(void* ModelPtr, CXTextA&ret);

//@隐藏{
//定义模型类型
//基础类型和嵌套类型或者数组类型
enum WoRefModelType {
	Bases = 0,
	Nesting = 1,
	Array = 2,
};
enum WoRefArrarType {
	stdvector,
	cxvector,
	null,
};
//反射模型的成员结构
struct WoRefModelMemberInfo {
	std::string typeName;   //模型名字
	WoRefModelType modelType = WoRefModelType::Bases;   //模型类型,用于标注是否为数组
	RefNestingretainModel arrayFunc;   //中转函数指针结构体
	int deviation = 0; //成员在当前结构体的偏移
};
/*
 * 类型信息
 * 需要记录:
 *  模型类型:为基础类型或者嵌套类型,又或者类等
 *  模型总尺寸:结构体的总尺寸
 *  类型名称:模型的类型名称
 *  是否数组:是否为数组类型
 *  反射函数:作用到此时,触发反射函数 bool(void*ModelPtr,const char*RefData)
 * */
struct WoRefModelInfo {
	//RefModelType type;  //模型类型
	bool isNesting; //是否为嵌套类型
	int size;  //模型总尺寸
	std::string typeName;//类型名称
	WoRefBaseModelFunc refFunc=nullptr; //反射函数
	WoRefBaseModelSezFunc sezFunc = nullptr;//序列化函数
	bool isArray = false;
	void* sizeFunc = nullptr;//当模型为数组时有效
	void* dataFunc = nullptr;//当模型为数组时有效
	//如果是嵌套类型,此map用以记录反射名称与对应的类型,类型可以是已注册的任何类型(除了自身,防止死锁)
	// map<显式反射名称,成员类型>
	std::map<std::string, WoRefModelMemberInfo*> memberMap;
};

//@隐藏}

//@备注 嵌套结构体注册,一般为struct
//@返回 返回注册的结构体句柄
//@别名 Wo数据反射_注册结构体Ex(类型名称,结构体尺寸)
WEBOAT_MODIFICATION WoRefModelHandle WEBOAT_API WoRefRegNestingModelEx(const char* typeName, int size);


//@备注 编译器无法知道结构体内有哪些成员,需要自行注册
//@参数 模型句柄 Wo数据反射_注册结构体() 注册得到的句柄
//@参数 反射显式名称 例如想将json内的`username`反射到此字段,则填写 "username"
//@参数 反射类型 类型名称,使用 Wo数据反射_取数据类型名称() 获取
//@参数 偏移地址 结构体成员偏移
//@参数 保留参数 注册类型为数组时为获取容器的函数,static_cast<void*>(&ff)
//@别名 Wo数据反射_结构体注册成员Ex(模型句柄,反射显式名称,反射类型,偏移地址,保留参数)
WEBOAT_MODIFICATION bool WEBOAT_API WoRefNestingModelRegMemberEx(WoRefModelHandle handle,
	const char* refName,
	const char* refType,
	int deviation,
	void* retain=nullptr
);

//@别名 Wo数据反射_注册基础类型Ex(类型名称,结构体尺寸,反射回调函数,序列化回调)
WEBOAT_MODIFICATION WoRefModelHandle WEBOAT_API WoRefRegBaseModelEx(const char* typeName, int size, WoRefBaseModelFunc refFunc, WoRefBaseModelSezFunc sezFunc=nullptr);

//@别名 Wo数据反射_填充基础类型Ex(待填充地址,反射名称,原始数据)
WEBOAT_MODIFICATION bool WEBOAT_API WoRefFillDataEx(void* ptr, const char* typeName, const char* data);

//@参数 类型名称 Wo数据反射_取数据类型名称() 获取
//@别名 Wo数据反射_取已注册模型句柄(类型名称)
WEBOAT_MODIFICATION WoRefModelHandle WEBOAT_API WoRefTypeNameGetHandle(const char* typeName);

//@别名 Wo数据反射_取模型反射函数(模型句柄)
WEBOAT_MODIFICATION WoRefBaseModelFunc WoRefTypeNameGetHandleFunc(WoRefModelInfo* info);

//@别名 Wo数据反射_模型是否为动态数组(模型名称,返回基础类型名称,返回数组结构类型)
WEBOAT_MODIFICATION bool WoRefModelIfisList(const char* typeName, CXTextA* ArrType=nullptr, WoRefArrarType* atype = nullptr);
/*@声明

//@备注 嵌套结构体注册,一般为struct
//@返回 返回注册的结构体句柄
//@别名 Wo数据反射_注册结构体(被注册结构体)
WoRefModelHandle WoRefRegNestingModel(通用型 type);

//@备注 注册基础类型,嵌套结构体内注册了此类型时会自动调用回调函数
//@别名 Wo数据反射_注册基础类型(数据类型,回调函数)
WoRefModelHandle WoRefModelRegBase(通用型 type,WoRefBaseModelFunc func);

//@备注 用于单独对某种类型的动态数组容器进行注册反射,如果已注册过结构体或者基础类型,此类的动态数组类型默认已注册
//@别名 Wo数据反射_注册动态数组(成员模型)
WoRefModelHandle WoRefModelRegCXArray(通用型 arrayModel);

//@备注 例如:
// . 整型 a
// . Wo数据反射_取数据类型名称(a)
// . 返回: "int"
//@别名 Wo数据反射_取数据类型名称(数据类型)
CXTextA WoRefGetVarTypeName(通用型 type);

//@备注 编译器无法知道结构体内有哪些成员,需要自行注册
//@参数 模型句柄 Wo数据反射_注册结构体() 注册得到的句柄
//@参数 反射显式名称 例如想将json内的`username`反射到此字段,则填写 "username"
//@参数 反射类型 任意类型,自动获取
//@参数 偏移地址 结构体成员偏移
//@别名 Wo数据反射_结构体注册成员(模型句柄,反射显式名称,反射类型,偏移地址)
WoRefModelHandle WoRefNestingModelRegMember(WoRefModelHandle handle,const char* refName,通用型 model,int deviation);


*/

//@隐藏{
WEBOAT_MODIFICATION bool WEBOAT_API WoRefFillPtrToJson(WoTemplateJson* json, const char* typeName, void* ptr);
WEBOAT_MODIFICATION void WEBOAT_API WoRefFillJsonData(WoTemplateJson* jsonMap,    //传入并且解析后的JSON
	const char* keyName,   //被映射的变量名
	const char* typeName,	//变量的原型类型
	void* ptr,   //欲写入的地址
	int deviation //欲写入地址的偏移
);

template<typename VEC, typename MODEL>
bool WoRefModelRegArrayCallBackTemplate(void* ModelPtr, const char* RefData) {
	std::string typeNameT(typeid(VEC).name());
	if (typeNameT.substr(0, strlen("class CXVector<")) == "class CXVector<") {
		WoTemplateJson jsonMap = WoTemplateJson::parse(RefData);
		if (!jsonMap.is_array()) { return false; }
		auto APrt = (VEC*)ModelPtr;
		for (auto iters = jsonMap.begin(); iters != jsonMap.end(); iters++) {
			MODEL mt;
			//APrt->add();
			auto& valueJson = *iters;
			//std::cout << vIters.key() <<std::endl;
			//WoRefFillJsonData(&valueJson, vIters.key().c_str(), typeid(MODEL).name(), (void*)&mt, 0);
			WoRefFillPtrToJson(&valueJson, typeid(MODEL).name(), (void*)&mt);
			APrt->getVector()->push_back(mt);
		}
	}
	return true;
}

template<typename VEC>
UINT WoRefModelRegArraySize(void* ptr) {
	if (ptr==nullptr) {
		return 0;
	}
	return ((VEC*)ptr)->size();
}
template<typename VEC>
void* WoRefModelRegArrayData(void* ptr) {
	if (ptr == nullptr) {
		return 0;
	}
	return ((VEC*)ptr)->data();
}
template<typename VEC, typename MODEL>
WoRefModelHandle WoRefModelRegArrayTemplate() {
	if (WoRefRegNestingModelEx(typeid(MODEL).name(), sizeof(MODEL)) == nullptr) { return nullptr; }
	WoRefModelHandle handle = WoRefRegBaseModelEx(typeid(VEC).name(), sizeof(VEC), WoRefModelRegArrayCallBackTemplate<VEC, MODEL>,nullptr);
	handle->sizeFunc = (void*)WoRefModelRegArraySize<VEC>;
	handle->dataFunc = (void*)WoRefModelRegArrayData<VEC>;
	return handle;
};

template<typename MODEL>
WoRefModelHandle WoRefRegNestingModelEx() {
	auto r = WoRefRegNestingModelEx(typeid(MODEL).name(), sizeof(MODEL));
	WoRefModelRegArrayTemplate<CXVector<MODEL>, MODEL>();
	return r;
};
#define WoRefRegNestingModel(type) WoRefRegNestingModelEx<type>()

template<typename MODEL>
WoRefModelHandle WoRefModelRegBaseEx(WoRefBaseModelFunc func,WoRefBaseModelSezFunc szeFunc) {
	auto r = WoRefRegBaseModelEx(typeid(MODEL).name(), sizeof(MODEL), func, szeFunc);
	WoRefModelRegArrayTemplate<CXVector<MODEL>, MODEL>();
	return r;
}
#define WoRefModelRegBase(type,refFunc,szeFunc) WoRefModelRegBaseEx<type>(func,szeFunc)

#define WoRefNestingModelRegMember(handle,refName,model,deviation) \
			WoRefNestingModelRegMemberEx(handle,refName,typeid(model).name(),deviation)

struct WoRefArrayCallbackModel {
	void* dataPtr = nullptr;
	void* resizePtr = nullptr;
};



#define  WoRefGetVarTypeName(type) typeid(type).name()


//@隐藏}



//@分组}
//@分组{	数据库_sqlite

WEBOAT_MODIFICATION void WEBOAT_API o(const char* fileName);

//@分组}



#endif